/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package formula.one.urjc;

import formula.one.urjc.escuderia.Escuderia;
import formula.one.urjc.mundial.Mundial;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;

import formula.one.urjc.piloto.Piloto;

/**
 *
 * @author santiago
 */
public class Metodos {
    
    final static String ESCUDERIA_FILE="escuderias.dat";
    final static String PILOTO_FILE="pilotos.dat";
    final static String CIRCUITO_FILE="circuitos.dat";        
    final static String MUNIDAL_FILE="mundial.dat"; 
    public void escribirFichero (String nombreFichero, Object objeto) {
        System.out.println("AÑADIMOS AL FICHERO") ;
        try {
            //Abrimos el fichero
            FileOutputStream fs = new FileOutputStream(nombreFichero,true) ;
            //Esta clase tiene el método writeObject() que necesitamos
            ObjectOutputStream os = new ObjectOutputStream(fs) ;
            //El método writeObject() serializa el objeto y lo escribe en el archivo
            os.writeObject(objeto) ;
            //Hay que cerrar siempre el archivo
            os.close() ;
        } catch(FileNotFoundException e) {
            e.printStackTrace() ;
        } catch(IOException e) {
            e.printStackTrace() ;
        }
        System.out.println("ALTA CORRECTA");
    }
    
    //metodo que permite leer un fichero de datos independiente del objeto que lea
    //Devuelve un listado de objetos
    public ArrayList<Object> leerFichero (String nombreFichero) {
        System.out.println("LEEMOS EL FICHERO") ;
        ArrayList<Object> contenido=new ArrayList<Object>();
        //Abrimos el fichero
        File f = new File(nombreFichero) ;
        FileInputStream fis = null ;
        ObjectInputStream leerObjeto = null ;
        try {
            fis = new FileInputStream(f) ;
            int longitudFichero = (int) f.length() ;
            byte [] datosLeidos = new byte[longitudFichero] ;
            for (int i=0; i<=datosLeidos.length; i++) {
            	leerObjeto = new ObjectInputStream(fis) ;
            	Object object =leerObjeto.readObject();
                contenido.add(object);             
            }
        }
        catch( Exception e ) {}
        finally {
            try {
                //Se cierra el archivo y listo.
                if( leerObjeto != null ) leerObjeto.close();
                System.out.println("FIN LECTURA") ;
            } catch( Exception ex ) {}
        }
        //System.out.println("Longitud Array Objeto: " + contenido.size()) ;
	return contenido;
    }
    
    //sobrecarga del método escirbir fichero
    public void escribirFichero (String nombreFichero, ArrayList<Object> objetos) {
        System.out.println("AÑADIMOS AL FICHERO") ;
        try {
            //Abrimos el fichero
            FileOutputStream fs = new FileOutputStream(nombreFichero,true) ;
            ObjectOutputStream os =null;
            //El método writeObject() serializa el objeto y lo escribe en el archivo
            for (int i=0;i<objetos.size();i++){
            	 //Esta clase tiene el m�todo writeObject() que necesitamos
            	//si no se crea un nuevo objectOutputStream cada vez escribe cosas ilegibles
            	os= new ObjectOutputStream(fs) ;
            	os.writeObject(objetos.get(i)) ;
            }
           
            //Hay que cerrar siempre el archivo
            if(os!=null){
                os.close() ;
            }
        } catch(FileNotFoundException e) {
            e.printStackTrace() ;
        } catch(IOException e) {
            e.printStackTrace() ;
        }
        System.out.println("ALTA CORRECTA");
    }
    
    public void borrarFichero(String nombreFichero){
    	File f = new File(nombreFichero) ;
        if(f.exists()){
           f.delete(); 
        }
    	
    }
    
    //////////metodos para acceder a los datos del fichero escuderias.dat
    public ArrayList<Object> getEscuderiasList(){
        return leerFichero(ESCUDERIA_FILE);
    }
    //Método  para acceder a una escudería determinada a través de su nombre
    public Escuderia getEscuderia(String nombre){
        Escuderia res=null;
        System.out.println("Paso Uno") ;
        ArrayList<Object> escuderias=leerFichero(ESCUDERIA_FILE);
        System.out.println("Longitud: " + escuderias.size()) ;
        for (int i=0; i< escuderias.size();i++){
            System.out.println(escuderias.get(i)) ;
            if(((Escuderia)escuderias.get(i)).getNombre().equals(nombre)){
                System.out.println("Encontrado") ;
                res=(Escuderia)escuderias.get(i);
            }
        }
        return res;
    }
    //método que modifica una escudería en la ventana de getión del dueño
    public boolean modificarEscuderia(Escuderia esc){
        boolean res=false;
        ArrayList<Object> escuderias=leerFichero(ESCUDERIA_FILE);
        for (int i=0; i< escuderias.size();i++){
                if(((Escuderia)escuderias.get(i)).getNombre().equals(esc.getNombre())){
                   escuderias.set(i, esc);
                   //borro el archvo escuderia
                   borrarFichero(ESCUDERIA_FILE);
                   escribirFichero(ESCUDERIA_FILE, escuderias);
                   res=true;
                   break;
                }
            }
        return res;
    }
     //método sobreescrito que modifica una escudería en modo administrador
     public boolean modificarEscuderia(Escuderia esc,String nombreAntiguo){
        boolean res=false;
        ArrayList<Object> escuderias=leerFichero(ESCUDERIA_FILE);
        for (int i=0; i< escuderias.size();i++){
                if(((Escuderia)escuderias.get(i)).getNombre().equals(nombreAntiguo)){
                   escuderias.set(i, esc);
                   //borro el archvo escuderia
                   borrarFichero(ESCUDERIA_FILE);
                   escribirFichero(ESCUDERIA_FILE, escuderias);
                   res=true;
                   break;
                }
            }
        return res;
    }
    
    public boolean eliminarEscuderia(String nombreEsc) {
       boolean res=false;
       //busco a ver si existe la escudería
       Escuderia esc=getEscuderia(nombreEsc);
       //si existe
       if(esc!=null){
           //obtengo todos las escuderias
           ArrayList<Object> escuderias=leerFichero(ESCUDERIA_FILE);
           //escuderias.remove((Object)esc);
           //borro la escudería
           for (int i=0; i< escuderias.size();i++){
                if(((Escuderia)escuderias.get(i)).getNombre().equals(nombreEsc)){
                    escuderias.remove(i);
                    res=true;
                }
            }
           //borro el fichero
           borrarFichero(ESCUDERIA_FILE);
           //creo el nuevo si hay objetos
           if(escuderias.size()>0){
              escribirFichero(ESCUDERIA_FILE, escuderias); 
           }
           
       }
        
        return res; 
    }
    
    /////////
    
    
    
    //////////metodos para acceder a los datos del fichero pilotos.dat
    public ArrayList<Object> getPilotoList(){
        return leerFichero(PILOTO_FILE);
    }
    
    //Método  para acceder a piloto determinado a través de su id
    public Piloto getPiloto(String nombre){
        Piloto res=null;
        ArrayList<Object> pilotos=leerFichero(PILOTO_FILE);
        for (int i=0; i< pilotos.size();i++){
            if(((Piloto)pilotos.get(i)).getNombre().equals(nombre)){
                res=(Piloto)pilotos.get(i);
            }
        }
        return res;
    }
    
    //Obtenemos un listado de pilotos con nombre completo
    public ArrayList<String> listadoPilotos () {
        ArrayList<Object> pilotos=leerFichero(PILOTO_FILE) ;
        ArrayList<String> nombrePilotos = new ArrayList<String>() ;
        for (int i=0; i<pilotos.size(); i++) {
            Piloto pilotoLista = (Piloto) pilotos.get(i) ;
            String nombre = pilotoLista.getNombre() ;
            String apellidos = pilotoLista.getApellidos() ;
            String nombreCompleto = nombre + " " + apellidos ;
            System.out.println("Nombre Completo: " + nombreCompleto) ;
            nombrePilotos.add(nombreCompleto) ;
        }
        return nombrePilotos ;
    }
    
    //Obtenemos de escuderias nombre y propietario
    /*
     * Se utiliza para validar el login de usuario escuderia
     * si valida el acceso devolverá la escudería correspondiente
     * en caso contraio devuelve null
     */
    //public boolean nombroEscuderias (String usuario, String clave) {
    public Escuderia nombroEscuderias (String usuario, String clave) {
        //la clave corresponde con el password
        Escuderia esc=getEscuderia(clave);
        if (esc!=null){
            //compruebo que el usuario sea correcto, si no es así devuelvo nulo
            if(!esc.getPropietario().equals(usuario)){
                esc=null;
            }
        }
        return esc;
        /*ArrayList<Object> escuderias=leerFichero(ESCUDERIA_FILE) ;
        boolean encontrado = false ;
        int i = 0;
        while (i<escuderias.size() && !encontrado) {
        //for (int i=0; i<escuderias.size(); i++) {
            Escuderia escuderiaLista = (Escuderia) escuderias.get(i) ;
            String nombreLista = escuderiaLista.getNombre() ;
            String propietarioLista = escuderiaLista.getPropietario() ;
            System.out.println("Nombre Escuderia: " + nombreLista) ;
            System.out.println("Propietario Escuderia: " + propietarioLista) ;
            if (usuario.equals(propietarioLista) && clave.equals(nombreLista)) {
                System.out.println("Encontrado") ;
                encontrado = true ;
            }
            i++ ;
        }
        System.out.println(encontrado) ;
        return encontrado ;*/
    }
    
    //Método que eliminará un piloto del fichero
    public boolean eliminarPiloto(String nombre,String apellidos){
        Boolean res=false;
        //leo el fichero antiguo
        ArrayList<Object> pilotos=leerFichero(PILOTO_FILE);
       
        for (int i=0; i< pilotos.size();i++){
            if(((Piloto)pilotos.get(i)).getNombre().equals(nombre)&& ((Piloto)pilotos.get(i)).getApellidos().equals(apellidos)){
               pilotos.remove(i);
               res=true;
               break;
            }
        }
        //BOrro el fichero antiguo
        borrarFichero(PILOTO_FILE);
        //creo el nuevo sy hay algo en la lista
        if(pilotos.size()>0){
           escribirFichero(PILOTO_FILE, pilotos);
        }
       return res;
    }
    /////////

    ///////////metodos para el archivo circuitos.daT
    public ArrayList<Object> getCircuitoList(){
        return leerFichero(CIRCUITO_FILE);
    }
   public int numeroCircuitos(){
       return getCircuitoList().size();
   }
    ///////////////

    public Mundial getMundial() {
        if(new File(MUNIDAL_FILE).exists() && leerFichero(MUNIDAL_FILE).size()==1){
            return (Mundial)leerFichero(MUNIDAL_FILE).get(0);
        }else{
            return null;
        }
        
    }
}
